package com.mes.task.manager;

import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import java.util.Vector;

import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.jdom2.Element;
import org.jdom2.output.Format;
import org.jdom2.output.XMLOutputter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import com.mes.basicdata.dao.iface.IEmployeeDao;
import com.mes.basicdata.dao.iface.IOperationDao;
import com.mes.basicdata.dao.iface.IOperationLinkDao;
import com.mes.basicdata.dao.iface.IRoutingDao;
import com.mes.basicdata.domain.Employee;
import com.mes.basicdata.domain.Operation;
import com.mes.basicdata.domain.OperationLink;
import com.mes.basicdata.domain.OperationPart;
import com.mes.basicdata.domain.OperationResource;
import com.mes.basicdata.domain.Routing;
import com.mes.basicdata.domain.XbomDetail;
import com.mes.check.domain.CheckTask;
import com.mes.common.manager.BasicManager;
import com.mes.common.util.SysUtil;
import com.mes.cotask.manager.iface.ICotaskManager;
import com.mes.inventory.dao.iface.IMaterialDao;
import com.mes.inventory.domain.Material;
import com.mes.schedule.domain.ScheduleEvent;
import com.mes.schedule.manager.iface.IScheduleEventManager;
import com.mes.task.manager.iface.IDemandManager;
import com.mes.task.manager.iface.IDemandTaskLinkManager;
import com.mes.task.manager.iface.IOperationTaskManager;
import com.mes.task.manager.iface.IPartTaskManager;
import com.mes.task.manager.iface.IWorkRecordManager;
import com.mes.task.dao.iface.IAssignmentDao;
import com.mes.task.dao.iface.IAssignmentDeviceDao;
import com.mes.task.dao.iface.IAssignmentWorkCenterDao;
import com.mes.task.dao.iface.IDemandDao;
import com.mes.task.dao.iface.IDemandTaskLinkDao;
import com.mes.task.dao.iface.IOperationTaskDao;
import com.mes.task.dao.iface.IOperationTaskLinkDao;
import com.mes.task.dao.iface.IPartTaskDao;
import com.mes.task.dao.iface.IPartTaskLinkDao;
import com.mes.task.dao.iface.ITaskMaterialDao;
import com.mes.task.dao.iface.ITaskPartDao;
import com.mes.task.dao.iface.ITaskResourceDao;
import com.mes.task.dao.iface.IWorkOrderDao;
import com.mes.task.dao.iface.IWorkRecordDao;
import com.mes.task.domain.Assignment;
import com.mes.task.domain.AssignmentDevice;
import com.mes.task.domain.AssignmentWorkCenter;
import com.mes.task.domain.Demand;
import com.mes.task.domain.DemandTaskLink;
import com.mes.task.domain.OperationTask;
import com.mes.task.domain.OperationTaskLink;
import com.mes.task.domain.PartTask;
import com.mes.task.domain.Task;
import com.mes.task.domain.TaskMaterial;
import com.mes.task.domain.TaskPart;
import com.mes.task.domain.TaskResource;
import com.mes.task.domain.WorkOrder;
import com.mes.task.domain.WorkRecord;

@Component
public class PartTaskManager extends BasicManager<PartTask> implements IPartTaskManager {

	public final static Log log = LogFactory.getLog(PartTaskManager.class);

	@Autowired
	private SysUtil sysUtil;
	@Autowired
	private IPartTaskDao partTaskDao;
	@Autowired
	IPartTaskLinkDao partTaskLinkDao;
	@Autowired
	private IRoutingDao routingDao;
	@Autowired
	private IOperationDao operationDao;
	@Autowired
	private IEmployeeDao employeeDao;
	@Autowired
	private IOperationTaskDao operationTaskDao;
	@Autowired
	private IOperationTaskManager operationTaskManager;
	@Autowired
	private ICotaskManager cotaskManager;
	@Autowired
	private IAssignmentDao assignmentDao;
	@Autowired
	private IAssignmentWorkCenterDao assignmentWorkCenterDao;
	@Autowired
	private IAssignmentDeviceDao assignmentDeviceDao;
	@Autowired
	private IOperationTaskLinkDao operationTaskLinkDao;
	@Autowired
	private IMaterialDao materialDao;
	@Autowired
	private ITaskMaterialDao taskMaterialDao;
	@Autowired
	private ITaskPartDao taskPartDao;
	@Autowired
	private ITaskResourceDao taskResourceDao;
	@Autowired
	private IWorkRecordDao workRecordDao;
	@Autowired
	IDemandDao demandDao;
	@Autowired
	IDemandManager demandManager;
	@Autowired
	IWorkRecordManager workRecordManager;
	@Autowired
	IDemandTaskLinkManager demandTaskLinkManager;
	@Autowired
	IDemandTaskLinkDao demandTaskLinkDao;
	@Autowired
	IWorkOrderDao workOrderDao;
	@Autowired
	IScheduleEventManager scheduleEventManager;
	@Override
	public boolean isPartTaskFinish(String partTaskUid) {
		// TODO Auto-generated method stub
		return false;
	}
	@Override
	public void delivery(String partTaskUid, float deliveryQty) throws Exception {
		// TODO Auto-generated method stub
		
	}
	@Override
	public void finishPartTask(PartTask partTask) throws Exception {
		// TODO Auto-generated method stub
		
	}
	@Override
	public void finishPartTask(String taskUid) throws Exception {
		// TODO Auto-generated method stub
		
	}
	@Override
	public void startPartTask(PartTask partTask) throws Exception {
		// TODO Auto-generated method stub
		
	}
	@Override
	public void startPartTask(String partTaskUid) throws Exception {
		// TODO Auto-generated method stub
		
	}
	@Override
	public void updatePlanQty(String taskUid, Float planQty) throws Exception {
		// TODO Auto-generated method stub
		
	}
	@Override
	public void cancelPartTask(String taskUid, String operator, String cancelReason) throws Exception {
		// TODO Auto-generated method stub
		
	}
	@Override
	public void rejectPartTask(String taskUid) throws Exception {
		// TODO Auto-generated method stub
		
	}

//	/**
//	 * 零件任务分解
//	 * 
//	 * @param partTask
//	 */
//	public void partTaskBreak(PartTask partTask) throws Exception {
//		String employeeUid = SysUtil.getSessionEmployeeUid();
//		if (employeeUid == null) {
//			throw new Exception("当前会话已经过期，请重新登录系统！");
//		}
//		Employee employee = employeeDao.getById(employeeUid);
//
//		String routingUid = partTask.getRoutingUid();
//		Routing routing = null;
//		if (routingUid == null || "".equals(routingUid)) {
//			routing = routingDao.getDefaultRouting(partTask.getPartUid(), employee.getDeptUid());
//			if (routing == null) {
//				throw new Exception("没有指定工艺路线信息，也无法找到该任务的缺省工艺！");
//			} else {
//				routingUid = routing.getUuid();
//			}
//		}
//
//		float totalRatio = 1;
//		List<Operation> operations = operationDao.getOperationListByRoutingUid(routingUid);
//		for (Operation operation : operations) {
//			totalRatio = totalRatio * operation.getBaseYield();
//		}
//
//		// List<OperationTask> operationTasks = new ArrayList<OperationTask>();
//		// List<AssignmentWorkCenter> assnWorkcenters = new
//		// ArrayList<AssignmentWorkCenter>();
//		// List<Assignment> assnTools = new ArrayList<Assignment>();
//		// List<OperationTaskLink> links = new ArrayList<OperationTaskLink>();
//
//		OperationTask predTask = null;
//		// 产生工序任务、工序链接、工作中心分派
//		for (Operation operation : operations) {
//			OperationTask operationTask = new OperationTask();
//			operationTask.setUuid(SysUtil.getUUID());
//			operationTask.setPartUid(partTask.getPartUid());
//			operationTask.setPartDrawingId(partTask.getPartDrawingId());
//			operationTask.setPartName(partTask.getPartName());
//			operationTask.setPartVersionId(partTask.getPartVersionId());
//			operationTask.setParentTaskUid(partTask.getUuid());
//			operationTask.setRoutingUid(routingUid);
//			operationTask.setTaskId(partTask.getTaskId());
//			operationTask.setBatchNum(partTask.getBatchNum());
//			operationTask.setDeptUid(partTask.getDeptUid());
//			operationTask.setMasterShopUid(partTask.getMasterShopUid());
//			operationTask.setModel(partTask.getModel());
//			operationTask.setPriority(partTask.getPriority());
//			operationTask.setTaskState(OperationTask.TASKSTATE_READY);
//			operationTask.setTaskName(operation.getOperationName());
//			operationTask.setOperationIdDesc(operation.getOperationIdDesc());
//			operationTask.setOperationUid(operation.getUuid());
//			operationTask.setOperationId(operation.getRoutingOperations().iterator().next().getOperationId());
//			operationTask.setTaskType(operation.getOperationType() == null ? "201" : operation.getOperationType());
//			operationTask.setPreOpTime(operation.getPreOpTime() == null ? 0 : operation.getPreOpTime());
//			operationTask.setRunTime(operation.getRunTime() == null ? 0 : operation.getRunTime());
//			operationTask.setPostOpTime(operation.getPostOpTime() == null ? 0 : operation.getPostOpTime());
//			operationTask.setEstiPreOpTime(operation.getEstiPreOpTime() == null ? 0 : operation.getEstiPreOpTime());
//			operationTask.setEstiRunTime(operation.getEstiRunTime() == null ? 0 : operation.getEstiRunTime());
//			operationTask.setPlanQty(partTask.getPlanQty() * operation.getBaseYield() / totalRatio);
//			operationTask.setTaskWork(
//					operationTask.getPreOpTime() + operationTask.getPlanQty() * operationTask.getRunTime());
//			operationTask.setEstiTaskWork(
//					operationTask.getEstiPreOpTime() + operationTask.getPlanQty() * operationTask.getEstiRunTime());
//			operationTask.setDueQty(0f);
//			operationTask.setCompleteQty(0f);
//			operationTask.setCompletePercent(0f);
//			operationTask.setCompleteWork(0f);
//			operationTask.setNoDefectQty(0f);
//			operationTask.setRepairQty(0f);
//			operationTask.setReworkQty(0f);
//			operationTask.setRejectQty(0f);
//			operationTask.setConstraintType(Task.CONSTRAINTTYPE_ASAP);
//			operationTask.setIsSuspended(false);
//			// operationTask.setMaterialState(0l);
//			// operationTask.setResourceState(0l);
//			// operationTask.setRoutineState(0l);
//			operationTask.setCreateTime(new Date());
//			operationTask.setCreatorUid(employeeUid);
//			operationTask.setIsCritical(operation.getIsCritical());
//			operationTask.setIsNeedCheck(operation.getIsNeedCheck());
//			operationTask.setWorkCenterUid(operation.getWorkCenterUid());
//			operationTask.setOpType(operation.getOpType());
//			// operationTasks.add(operationTask);
//			operationTaskDao.add(operationTask);
//
//			totalRatio = totalRatio / operation.getBaseYield();
//
//			// 产生工作中心分派
//			AssignmentWorkCenter assnWorkcenter = new AssignmentWorkCenter();
//			assnWorkcenter.setUuid(SysUtil.getUUID());
//			assnWorkcenter.setOperationTaskUid(operationTask.getUuid());
//			assnWorkcenter.setWorkCenterUid(operation.getWorkCenterUid());
//			assnWorkcenter.setAssnType(Assignment.ASSNTYPE_WORKCENTER);
//			assnWorkcenter.setAssnQty(1d);
//			assnWorkcenter.setEffective(true);
//			assnWorkcenter.setCreateTime(new Date());
//			assnWorkcenter.setCreatorUid(employeeUid);
//			// assnWorkcenters.add(assnWorkcenter);
//			assignmentWorkCenterDao.add(assnWorkcenter);
//
//			// 产生工序链接
//			if (predTask != null) {
//				OperationTaskLink link = new OperationTaskLink();
//				link.setUuid(SysUtil.getUUID());
//				link.setPredOperationTaskUid(predTask.getUuid());
//				link.setSuccOperationTaskUid(operationTask.getUuid());
//				link.setLinkQty(0f);
//				link.setLinkLag(0);
//				link.setLinkType(OperationTaskLink.LINKTYPE_FTS);
//				// links.add(link);
//				operationTaskLinkDao.add(link);
//			}
//			predTask = operationTask;
//
//			// 产生工序物料需求
//			Set<OperationPart> operationParts = operation.getOperationParts();
//			for (OperationPart operationPart : operationParts) {
//				TaskPart taskPart = new TaskPart();
//				taskPart.setTaskUid(operationTask.getUuid());
//				taskPart.setPartUid(operationPart.getConsumedPartUid());
//				taskPart.setSingleIn(operationPart.getConsumedQuantity());
//				taskPart.setSingleOut(operationPart.getProducedQuantity());
//				taskPart.setReqQty(operationTask.getPlanQty() * operationPart.getConsumedQuantity()
//						/ operationPart.getProducedQuantity());
//				taskPart.setReqType(TaskPart.REQTYPE_MATERIAL);
//				taskPart.setAllocatedQty(0f);
//				// taskPart.setPrepareWarehouseUid(prepareWarehouseUid);
//				taskPart.setEffective(true);
//				taskPartDao.add(taskPart);
//			}
//
//			// 产生工序资源需求
//			Set<OperationResource> operationResources = operation.getOperationResources();
//			for (OperationResource operationRes : operationResources) {
//				TaskResource taskResource = new TaskResource();
//				taskResource.setOperationTaskUid(operationTask.getUuid());
//				taskResource.setResourceUid(operationRes.getResourceUid());
//				taskResource.setReqQty(operationRes.getResourceReqQty());
//				taskResource.setAssnState(0);
//				taskResource.setAssnType(Assignment.ASSNTYPE_TOOL);
//				taskResource.setCreatorUid(SysUtil.getSessionEmployeeUid());
//				taskResource.setCreateTime(new Date());
//				taskResource.setEffective(true);
//				taskResourceDao.add(taskResource);
//			}
//		}
//	}
//
//	// 在源物料只有一个的情况下，是否同时进行物料自动分批
//	// private boolean m_allow_material_split;
//	// private Material root_material;
//	// private PartTask root_parttask;
//	// private OperationTask root_operationtask;
//
//	/**
//	 * 任务分批 功能描述 计划员或是调度员根据实际能力情况或是物料要求，将一个任务分为多个任务 状态迁移
//	 */
//	/**
//	 * 零件任务分批，任务分批的过程中一概不处理物料。物料在任务分批后单独进行分堆，并与任务绑定
//	 * 
//	 * @param taskuid_root
//	 *            开始分批的工序任务uid
//	 * @param taskList
//	 *            分批为的任务列表
//	 * @param include_self
//	 *            是否保留开始分批的工序任务，即分批是从选中的这个工序开始分批还是从后面的工序开始分批
//	 */
//	public void doSplitPartTask(String taskuid_root, List<OperationTask> taskList, boolean include_self) {
//
//		try {
//			// 取得原批次中开始分批的工序任务
//			OperationTask root_operationtask = operationTaskDao.getById(taskuid_root);
//			// 取得根零件任务
//			PartTask root_parttask = partTaskDao.getById(root_operationtask.getParentTaskUid());
//
//			// 判断分批后是否继续使用原批次
//			boolean isUseOldTaskBatchNum = false;
//			for (OperationTask aTask : taskList) {
//				if (aTask.getBatchNum().equals(root_operationtask.getBatchNum())) {
//					isUseOldTaskBatchNum = true;
//					break;
//				}
//			}
//
//			if (isUseOldTaskBatchNum == true)
//				useOld(taskuid_root, taskList);// 分批后继续使用原批次
//			else
//				SaveOld(taskuid_root, taskList, include_self);// 分批后不使用原批次
//
//			/**
//			 * 处理分批工序的派工记录: 如果已经派工并已开始加工，那么封存原派工，并将派工记录设为已完成。
//			 * 如果派工尚未开始加工，那么删除原来的派工记录。
//			 */
//			releaseTaskAssignment(taskuid_root);
//
//			// 对协作任务进行分批处理
//			cotaskManager.splitCotask(root_parttask.getPartUid(), root_parttask.getBatchNum());
//			cotaskManager = null;
//		}
//
//		catch (Exception e) {
//			e.printStackTrace();
//		}
//
//	}
//
//	/**
//	 * 分批后继续使用原批次
//	 */
//	private void useOld(String operationTaskuid, List<OperationTask> taskList) throws Exception {
//		/**
//		 * 找到分批前的零件任务号、零件任务和工序任务
//		 */
//		String partTaskuid = root_parttask.getUuid();
//
//		/**
//		 * 循环处理所有的分批任务，其中也包括原批次的任务
//		 */
//		for (OperationTask aTask : taskList) {
//			if (aTask.getBatchNum().equals(root_operationtask.getBatchNum()))
//				doOldBatch(partTaskuid, operationTaskuid, aTask);// 对原批次的处理
//			else
//				doNewBatch(partTaskuid, operationTaskuid, aTask, false);// 对新分批次的处理
//		}
//	}
//
//	/**
//	 * 分批后将原批次存档
//	 */
//	private void SaveOld(String operationTaskuid, List<OperationTask> taskList, boolean include_self) throws Exception {
//		/**
//		 * 找到分批前的零件任务号
//		 */
//		OperationTask ot = operationTaskDao.getById(operationTaskuid);
//		String partTaskuid = ot.getParentTaskUid();
//
//		/**
//		 * 循环处理新分批的任务
//		 */
//		for (OperationTask aTask : taskList) {
//			doNewBatch(partTaskuid, operationTaskuid, aTask, include_self);
//		}
//
//		/**
//		 * 处理分批前的任务——将其封存
//		 */
//		saveOldBatch(partTaskuid, operationTaskuid, include_self);
//	}
//
//	/**
//	 * 处理一个新分批的任务 参数 partTaskuid 原批次的零件任务号 operationTaskuid 原批次的工序任务号，即分批工序
//	 * aTask 新分批的工序任务，注意：其任务号在本方法里要重新注册
//	 */
//	/**
//	 * 处理一个新分批的任务
//	 * 
//	 * @param partTaskuid
//	 *            分批前的零件任务的uid
//	 * @param operationTaskuid
//	 *            分批前，开始分批的工序任务的uid
//	 * @param aTask
//	 *            新分出来的批次的工序任务，对应分批前开始分批的工序任务，批次号和在制数不一样了
//	 * @param include_self
//	 *            分批的时候是否包含
//	 * @throws Exception
//	 */
//	private void doNewBatch(String partTaskuid, String operationTaskuid, OperationTask aTask, boolean include_self)
//			throws Exception {
//
//		int i;
//		/**
//		 * 获取分批前的零件任务和工序任务
//		 */
//
//		PartTask temp_parttask = partTaskDao.getById(partTaskuid);
//
//		double sglInQty = temp_parttask.getPlanQty();
//
//		String newTaskuid = SysUtil.getUUID();
//		/**
//		 * 对拷贝的零件任务修改以下信息 任务号、批次号、源批次号、计划数、分批原因
//		 */
//		String rootBatchnum = temp_parttask.getBatchNum();
//		temp_parttask.setUuid(newTaskuid);
//		temp_parttask.setBatchNum(aTask.getBatchNum());
//		temp_parttask.setRootBatchNum(rootBatchnum);
//
//		float planQty = temp_parttask.getPlanQty() * aTask.getPlanQty()
//				/ (root_operationtask.getPlanQty() - root_operationtask.getRejectQty());
//
//		if (planQty <= 0)
//			throw new Exception("新批次在制数不能为0！");
//
//		temp_parttask.setPlanQty(planQty);
//
//		temp_parttask.setNotes(aTask.getNotes());
//		temp_parttask.setReasonCode(aTask.getReasonCode());
//		// 继承父任务的交货期与关键等级
//		if (aTask.getLateFinish() == null)
//			temp_parttask.setLateFinish(temp_parttask.getLateFinish());
//		else
//			temp_parttask.setLateFinish(aTask.getLateFinish());
//
//		// 分卡不继承主卡的悬挂状态
//		temp_parttask.setSuspended(PartTask.SUSPENDED_NO);
//
//		temp_parttask.setCreateTime(new Date());
//		temp_parttask.setCreatorUid(SysUtil.getSessionEmployeeUid());
//
//		/**
//		 * 将修改后的拷贝信息存进数据库
//		 */
//		partTaskDao.add(temp_parttask);
//
//		/**
//		 * 维护需求与任务的关系 最佳方案是让用户手工调整新分批的任务与需求之间的关系
//		 * 目前只能将原来需求与任务的关联，依照计划数，按比例分配到各分批的任务上——已禁用
//		 * 
//		 * java.util.Vector linkCollectionForPartTask = new java.util.Vector();
//		 * mm.task.object.Link temp_link = new mm.task.object.Link();
//		 * 
//		 * linkCollectionForPartTask = temp_link.getLinkByPreduid(partTaskuid);
//		 * java.util.Iterator linkCollectionIterator =
//		 * linkCollectionForPartTask. iterator(); int i = 0; while
//		 * (linkCollectionIterator.hasNext()) { mm.task.object.Link
//		 * succlinkforpart = (mm.task.object.Link)
//		 * linkCollectionForPartTask.elementAt(i);
//		 * succlinkforpart.setPredUID(newTaskuid);
//		 * succlinkforpart.setLinkQty(succlinkforpart.getLinkQty() *
//		 * aTask.getPlanQty() / (root_operationtask.getPlanQty() -
//		 * root_operationtask.getCheck8Qty())); //succlinkforpart.insertLink();
//		 * //已禁用，最佳方案是让用户手工调整需求和任务之间的关系 linkCollectionIterator.next(); i++; }
//		 * logger.info("_____update_____relation between demand and new
//		 * task_____");
//		 */
//		/**
//		 * 获得分批前的工序任务的一个拷贝
//		 */
//		OperationTask temp_firstoperationtask = operationTaskDao.getById(operationTaskuid);
//		String temp_newFirstOperationTaskuid = SysUtil.getUUID();
//		/**
//		 * 对拷贝的工序任务修改以下信息 任务号、任务名、批次号、父任务、工时、计划数、完成数和报废数
//		 */
//		temp_firstoperationtask.setUuid(temp_newFirstOperationTaskuid);
//		temp_firstoperationtask.setTaskName(aTask.getTaskName());
//		temp_firstoperationtask.setBatchNum(aTask.getBatchNum());
//		temp_firstoperationtask.setParentTaskUid(newTaskuid);
//		temp_firstoperationtask.setTaskWork(
//				temp_firstoperationtask.getPreOpTime() + temp_firstoperationtask.getRunTime() * aTask.getPlanQty());
//		temp_firstoperationtask.setPlanQty(aTask.getPlanQty());
//		temp_firstoperationtask.setCompleteQty(aTask.getCompleteQty());
//		temp_firstoperationtask.setRejectQty(0f); // 报废全改为零，报废信息反映在原批次上
//		// 不要悬挂
//		temp_firstoperationtask.setIsSuspended(false);
//		if (temp_firstoperationtask.getCompleteQty() >= temp_firstoperationtask.getPlanQty()) {
//			if (temp_firstoperationtask.getCompleteQty() > temp_firstoperationtask.getPlanQty())
//				temp_firstoperationtask.setCompleteQty(temp_firstoperationtask.getPlanQty());
//			temp_firstoperationtask.setTaskState(OperationTask.TASKSTATE_COMPLETED);
//		} else {
//			if (temp_firstoperationtask.getCompleteQty() > 0)
//				temp_firstoperationtask.setTaskState(OperationTask.TASKSTATE_STARTED);
//			else
//				temp_firstoperationtask.setTaskState(OperationTask.TASKSTATE_READY);
//		}
//
//		/**
//		 * 将修改后的拷贝信息存进数据库
//		 */
//		operationTaskDao.add(temp_firstoperationtask);
//
//		Set<TaskPart> taskPartList = root_operationtask.getTaskParts();
//		TaskPart newtaskpart = new TaskPart();
//		for (TaskPart objTaskPart : taskPartList) {
//			newtaskpart.setAllocatedQty(0f);
//			newtaskpart.setApplyQty(0f);
//			newtaskpart.setCreateTime(new Timestamp(new Date().getTime()));
//			newtaskpart.setEffective(true);
//			newtaskpart.setPartUid(objTaskPart.getPartUid());
//			newtaskpart.setPreAssignQty(0f);
//			newtaskpart.setSingleIn(objTaskPart.getSingleIn());
//			newtaskpart.setReqQty(objTaskPart.getSingleIn() * temp_firstoperationtask.getPlanQty());
//			newtaskpart.setReqType(0);
//			newtaskpart.setSingleOut(objTaskPart.getSingleOut());
//			newtaskpart.setTaskUid(temp_firstoperationtask.getUuid());
//			taskPartDao.add(newtaskpart);
//
//		}
//
//		// logger.info("_____finish_____copy_____operationtask_____");
//
//		/**
//		 * 如果分批任务有加工记录，那么构造新分批任务的workrec，使得新分出的首道工序任务能有其完成者
//		 */
//
//		// modified by hyl 06-05-18,注释掉了加工记录拷贝的部分
//		/*
//		 * mm.material.object.WorkRec workRec = new
//		 * mm.material.object.WorkRec(); java.util.ArrayList workRecList =
//		 * workRec.getWorkRecList(operationTaskuid); java.util.Iterator
//		 * workRecIterator = workRecList.iterator(); while
//		 * (workRecIterator.hasNext()) { workRec= (mm.material.object.WorkRec)
//		 * workRecIterator.next();
//		 * workRec.setTaskUID(temp_newFirstOperationTaskuid); workRec.addItem();
//		 * }
//		 * 
//		 * logger.info("_____finish_____copy_____workrec_____");
//		 * 
//		 */
//		// modified by hyl 06-05-18,注释掉了加工记录拷贝的部分
//		/**
//		 * 获取分批前工序任务链接关系的一个拷贝 并修改链接的紧后任务号和链接数量——数量按比例修改 最后保存进数据库
//		 * 
//		 * 检验分批时，include_self为true，链接关系在原零件任务的检验工序和新分任务的检验工序之间建立
//		 */
//
//		OperationTaskLink temp_firstOperationTaskLink = new OperationTaskLink();
//		if (include_self == true) {
//			OperationTaskLink temp_firstoperationlink = new OperationTaskLink();
//			temp_firstoperationlink.setPredOperationTaskUid(operationTaskuid);
//			temp_firstoperationlink.setSuccOperationTaskUid(temp_newFirstOperationTaskuid);
//			temp_firstoperationlink.setLinkType(OperationTaskLink.LINKTYPE_FTS);
//			temp_firstoperationlink.setLinkQty(aTask.getPlanQty());
//			operationTaskLinkDao.add(temp_firstoperationlink);
//		} else if (include_self == false) {
//			OperationTask ot = operationTaskDao.getById(operationTaskuid);
//			Set<OperationTaskLink> first_operationTaskLink = ot.getPredOperationTaskLinks();
//			for (OperationTaskLink temp_firstoperationlink : first_operationTaskLink) {
//				temp_firstoperationlink.setSuccOperationTaskUid(temp_newFirstOperationTaskuid);
//				temp_firstoperationlink.setLinkQty(temp_firstoperationlink.getLinkQty() * aTask.getPlanQty()
//						/ (root_operationtask.getPlanQty() - root_operationtask.getRejectQty()));
//				operationTaskLinkDao.add(temp_firstoperationlink);
//			}
//		}
//
//		// logger.info("_____finish_____copy_____operationtask_____");
//
//		/**
//		 * 拷贝后续的工序任务——做相应的修改和调整
//		 */
//		// 将此方法的倒数第二个参数值赋为0，目的是判断是不是第一次调用此方法
//		this.copyOperationTasks(newTaskuid, operationTaskuid, temp_newFirstOperationTaskuid, aTask.getPlanQty(), 0,
//				aTask.getBatchNum(), taskPartList);
//
//		// logger.info("_____finish_____copy_____operationtask_____");
//
//		/**
//		 * 检查当前分批出来的工序 (1)完成数大于等于计划数的工序置为完成。 (2)完成数大于零但小于计划数的工序置为已开始。
//		 * (3)完成数为零的时候，如果原状态为已派工或已开始，那么改为已分派，否则保持状态不变。
//		 */
//		/*
//		 * if (aTask.getCompleteQty() >= aTask.getPlanQty()) {
//		 * mm.task.object.Task currOpeTask = mm.task.object.Task.findByTaskUID(
//		 * temp_newFirstOperationTaskuid); currOpeTask.setTaskState(209);
//		 * currOpeTask.editItem(); } else if (aTask.getCompleteQty() <
//		 * aTask.getPlanQty() && aTask.getCompleteQty() > 0) {
//		 * mm.task.object.Task currOpeTask = mm.task.object.Task.findByTaskUID(
//		 * temp_newFirstOperationTaskuid); currOpeTask.setTaskState(207);
//		 * currOpeTask.editItem(); } else if (aTask.getCompleteQty() == 0) {
//		 * mm.task.object.Task currOpeTask = mm.task.object.Task.findByTaskUID(
//		 * temp_newFirstOperationTaskuid); if (currOpeTask.getTaskState() == 206
//		 * || currOpeTask.getTaskState() == 207) {
//		 * currOpeTask.setTaskState(205); currOpeTask.editItem(); } }
//		 */
//		// logger.info("_____check_____current operationtask complete or
//		// not_____");
//
//		/**
//		 * 新加补丁 2005-05-23 新分批生成的零件任务的计划数量不再等比例取原批次的计划数量，改为末道工序的计划数量
//		 * 用下面这段代码处理分批零件任务的计划数量
//		 */
//		temp_parttask = partTaskDao.getById(newTaskuid);
//		temp_parttask.setPlanQty(this.findLastOperationTask(newTaskuid).getPlanQty());
//
//		/*
//		 * //设置零件任务的状态 mm.task.object.Task
//		 * firstchildtask=temp_parttask.findByTaskUID((String)temp_parttask.
//		 * getTaskUIDByParentUID(temp_parttask.getTaskUID()).get(0)); if
//		 * (firstchildtask.getCompleteQty()>0){ if
//		 * (temp_parttask.getTaskState()!=106) {
//		 * temp_parttask.setTaskState(105); //已开始 } } else{ if
//		 * (temp_parttask.getTaskState()==105) {
//		 * temp_parttask.setTaskState(104); //已投产 } }
//		 */
//
//		partTaskDao.update(temp_parttask);
//		// 统一的工序距离调用
//		this.refreshTaskDistance(newTaskuid, null, null);
//		// logger.info("_____update new parttask planqty_____equal last
//		// operationtask planqty_____");
//	}
//
//	/**
//	 * 处理分批前的任务——将其封存 参数 partTaskuid 原批次的零件任务号 operationTaskuid 原批次的工序任务号，即分批工序
//	 */
//	private void saveOldBatch(String partTaskuid, String operationTaskuid, boolean include_self) throws Exception {
//
//		// logger.info("_____update_____relation between demand and old
//		// task_____");
//
//		/**
//		 * 封存前的操作二 删除后续的工序任务 并引发及联删除taskpart,links和assignments
//		 */
//		Vector<String> current_operationTasks = new Vector<String>();
//		findSuccOperation(operationTaskuid, partTaskuid, current_operationTasks); // 找到所有的后续工序
//
//		Iterator current_operationtasksIterator = current_operationTasks.iterator();
//		OperationTask temp_task = new OperationTask();
//		while (current_operationtasksIterator.hasNext()) {
//			String temp_taskuid = (String) current_operationtasksIterator.next();
//			if (temp_taskuid.equals(operationTaskuid) && include_self == true) {
//				continue;
//			}
//			// 不删除，只是将数量置为0
//			temp_task = operationTaskDao.getById(temp_taskuid);
//			temp_task.setPlanQty(0d);
//			temp_task.setTaskState(OperationTask.TASKSTATE_CANCELED);
//
//			// 将所有已派工的任务应该清除
//			operationTaskDao.update(temp_task);
//			// temp_task.deleteItem(temp_taskuid); // 删除后续工序
//		}
//
//		// logger.info("_____delete_____old operationTask_____");
//
//		/**
//		 * 封存前的操作三 将原零件任务设为结转
//		 */
//
//		PartTask partTask = partTaskDao.getById(partTaskuid);
//
//		partTask.setPlanQty(0d);
//		partTask.setTaskState(PartTask.TASKSTATE_COMPLETED);// 其实这里非正常结转应该有另外一个状态
//		partTaskDao.update(partTask);
//
//		this.syncPartTaskPlanInfo(partTask);
//
//		// logger.info("_____old partTask_____turned_____");
//
//		/**
//		 * 将原指令挂接移除
//		 */
//		demandTaskLinkManager.deleteLinksByTaskUid(partTaskuid);
//
//	}
//
//	/**
//	 * 处理分批前的任务——继续使用原批次的任务 参数 partTaskuid 原批次的零件任务号 operationTaskuid
//	 * 原批次的工序任务号，即分批工序 aTask 分批后的原批次工序任务，里面包含了分批后的信息
//	 */
//	private void doOldBatch(String partTaskuid, String operationTaskuid, OperationTask aTask) throws Exception {
//
//		int i;
//
//		/**
//		 * 处理一、更改零件任务的计划数量，并保存进数据库
//		 */
//
//		root_parttask.setPlanQty(aTask.getPlanQty());
//
//		/**
//		 * 处理一、更改零件任务的计划数量，并保存进数据库
//		 */
//
//		PartTask partTask = partTaskDao.getById(root_parttask.getUuid());
//
//		partTask.setPlanQty(aTask.getPlanQty());
//		partTask.setNotes(aTask.getNotes());
//		partTaskDao.update(partTask);
//
//		this.syncPartTaskPlanInfo(partTask);
//
//		/**
//		 * 处理二 维护该任务与需求的对应关系 最佳方案是不在这里维护，让用户手工维护——不在这里维护需求与任务的数量维护
//		 * 
//		 * java.util.Vector currentPartTaskPostLinks = new java.util.Vector();
//		 * mm.task.object.Link temp_link = new mm.task.object.Link();
//		 * currentPartTaskPostLinks = temp_link.getLinkByPreduid(partTaskuid);
//		 * java.util.Iterator currentparttaskpostlinksIterator =
//		 * currentPartTaskPostLinks.iterator();
//		 * 
//		 * int i = 0; mm.task.object.Link temp_currentpartpostlink = new
//		 * mm.task.object.Link(); while
//		 * (currentparttaskpostlinksIterator.hasNext()) {
//		 * temp_currentpartpostlink = (mm.task.object.Link)
//		 * currentPartTaskPostLinks. elementAt(i);
//		 * temp_currentpartpostlink.setLinkQty(currentPartTask.getPlanQty() *
//		 * aTask.getPlanQty() / (root_operationtask.getPlanQty() -
//		 * root_operationtask.getCheck8Qty()));
//		 * //temp_currentpartpostlink.updateLinks(); //已禁用，不在这里维护需求与任务的数量
//		 * currentparttaskpostlinksIterator.next(); i++; }
//		 * 
//		 * logger.info("_____update_____relation between demand and old
//		 * task_____");
//		 */
//		/**
//		 * 处理三 更改分批工序任务与其紧前工序的任务链接关系，即修改链接数量
//		 * 
//		 * java.util.Vector first_operationTaskLink = new java.util.Vector();
//		 * mm.task.object.Link temp_firstOperationTaskLink = new
//		 * mm.task.object.Link(); first_operationTaskLink =
//		 * temp_firstOperationTaskLink.getLinkBySccuid( operationTaskuid);
//		 * java.util.Iterator first_operationLinkIterator =
//		 * first_operationTaskLink. iterator(); i = 0; while
//		 * (first_operationLinkIterator.hasNext()) { mm.task.object.Link
//		 * temp_firstoperationlink = (mm.task.object.Link)
//		 * first_operationTaskLink.elementAt(i);
//		 * temp_firstoperationlink.setLinkQty(temp_firstoperationlink.getLinkQty
//		 * () * aTask.getPlanQty() / (root_operationtask.getPlanQty() -
//		 * root_operationtask.getCheck8Qty()));
//		 * temp_firstoperationlink.updateLinks();
//		 * first_operationLinkIterator.next(); i++; }
//		 * 
//		 * logger.info("_____update_____current oldOperationTask_____linkqty");
//		 */
//		/**
//		 * 处理四 更改后续工序任务的计划数量，并保存进数据库 同时修改taskpart,links和assignments中的相关信息
//		 */
//		Vector<String> collection_operationtaskuid = new Vector<String>();
//		PartTask temp_task = partTaskDao.getById(partTaskuid);
//		List<OperationTask> current_operationTasks = temp_task.getOperationTasks();
//		for (OperationTask temp_currentOperationTask : current_operationTasks) {
//			String temp_taskuid = temp_currentOperationTask.getUuid();
//			collection_operationtaskuid.add(temp_taskuid);
//		}
//
//		ArrayList<TaskPart> taskPartList = new ArrayList<TaskPart>();
//
//		// modified by dbc 2006-08-16 修改了此方法的倒数第三个参数值，目的是判断是不是第一次调用此方法
//		this.changePropertyOfOperationTaskAndLinks(operationTaskuid, partTaskuid, collection_operationtaskuid,
//				aTask.getPlanQty(), 0, aTask.getCompleteQty(), aTask.getBatchNum(), taskPartList);
//
//		// logger.info("_____update_____succ oldOperationTask_____qty");
//
//		/**
//		 * 处理五 修改当前工序任务的计划数和完成数
//		 */
//		root_operationtask.setPlanQty(aTask.getPlanQty());
//		root_operationtask.setCompleteQty(aTask.getCompleteQty());
//		if (root_operationtask.getCompleteQty() >= root_operationtask.getPlanQty()) {
//			if (root_operationtask.getCompleteQty() > root_operationtask.getPlanQty())
//				root_operationtask.setCompleteQty(root_operationtask.getPlanQty());
//			root_operationtask.setTaskState(OperationTask.TASKSTATE_COMPLETED);
//		} else {
//			if (root_operationtask.getCompleteQty() > 0) {
//				root_operationtask.setTaskState(OperationTask.TASKSTATE_STARTED);
//			}
//		}
//		operationTaskDao.update(root_operationtask);
//
//		// 暂时无用
//
//		// taskPartList = TaskPart.findTaskPartsByTaskUID(root_operationtask
//		// .getTaskUID());
//		// TaskPart objTaskPart = new TaskPart();
//		// for (i = 0; i < taskPartList.size(); i++) {
//		// objTaskPart = (mm.task.object.TaskPart) taskPartList.get(i);
//		// objTaskPart.setQtyReq(objTaskPart.getSingleIn()
//		// * root_operationtask.getPlanQty());
//		// objTaskPart.editItem();
//		// }
//
//		this.refreshTaskDistance(partTaskuid, null, null);
//
//		// logger.info("_____update_____current oldOperationTask_____planqty and
//		// completeqty");
//	}
//
//	/**
//	 * 复制工序任务，递规函数
//	 * 
//	 * @throws Exception
//	 */
//	public void copyOperationTasks(String parttaskuid, String oldoperationtaskuid, String newoperationtaskuid,
//			float temp_planqty, float temp_sumqty, String batchnum, Set<TaskPart> taskpartlist) throws Exception {
//
//		OperationTask oldOperationTask = operationTaskDao.getById(oldoperationtaskuid);
//
//		// 复制工作中心分配信息
//		Set<AssignmentWorkCenter> assignmentWorkCenters = oldOperationTask.getAssignmentWorkCenters();
//		if (assignmentWorkCenters.size() > 0) {
//			for (AssignmentWorkCenter assnWorkCenter : assignmentWorkCenters) {
//				assnWorkCenter.setOperationTaskUid(newoperationtaskuid);
//				assnWorkCenter.setUuid(SysUtil.getUUID());
//				assignmentWorkCenterDao.add(assnWorkCenter);
//			}
//		}
//
//		String newcreatedtaskuid = "";
//
//		Set<OperationTaskLink> succOperationTaskLinks = oldOperationTask.getSuccOperationTaskLinks();
//
//		float singleout = 1;
//		for (OperationTaskLink temp_link : succOperationTaskLinks) {
//			// 得到后续任务的taskuid
//			String temp_succuid = temp_link.getSuccOperationTaskUid();
//			try {
//				// 得到任务对象
//				OperationTask succOperationTask = operationTaskDao.getById(temp_succuid);
//
//				if (succOperationTask == null)
//					continue;
//
//				// 更改这个对象的planqty，准备插入一个新的任务
//
//				// add by zly 标示是否为试样工序,对于试样工序，不更改计划数量
//				boolean isTestOperation = false;
//				Operation tmpOperation = operationDao.getById(succOperationTask.getOperationUid());
//				if (!succOperationTask.getTaskType().equalsIgnoreCase(OperationTask.TASKTYPE_SAMPLE)) {
//					// modified by dbc 2006-08-16 begin
//					if (tmpOperation != null && temp_sumqty != 0)
//						singleout = tmpOperation.getBaseYield();
//					succOperationTask.setPlanQty(singleout * temp_planqty);
//					temp_planqty = succOperationTask.getPlanQty();// 取得当前工序的在制数量，以供下一工序使用
//					// modified by dbc 2006-08-16 end
//				} else {
//					if (tmpOperation != null) {
//						if (tmpOperation.getSamplePercent() > 0 && tmpOperation.getSamplePercent() < 1)// 如果采用百分比试样
//							succOperationTask
//									.setPlanQty((float) Math.ceil(temp_planqty * tmpOperation.getSamplePercent()));// 按照百分比设置试样
//						else if (tmpOperation.getSampleQty() > 0)// 如果数量为固定试样数量
//							succOperationTask.setPlanQty(tmpOperation.getSampleQty());
//						else
//							succOperationTask.setPlanQty(1f);// 缺省试样数量为1
//					}
//					isTestOperation = true;
//				}
//				tmpOperation = null;
//
//				// 更改工时
//				succOperationTask
//						.setTaskWork(succOperationTask.getPreOpTime() + succOperationTask.getRunTime() * temp_planqty);
//				// 更改任务唯一号
//				newcreatedtaskuid = SysUtil.getUUID();
//				succOperationTask.setUuid(newcreatedtaskuid);
//				// 设置批次号
//				succOperationTask.setBatchNum(batchnum);
//				// 设置parenttaskuid
//				succOperationTask.setParentTaskUid(parttaskuid);
//
//				// 不要悬挂
//				succOperationTask.setIsSuspended(false);
//				// 插入一条工序任务
//				// todo 2012-11-17
//				// todo
//				// 对于是否派工没有处理好
//				succOperationTask.setTaskState(OperationTask.TASKSTATE_READY);
//				if (succOperationTask.getCompleteQty() >= succOperationTask.getPlanQty()) {
//					succOperationTask.setTaskState(OperationTask.TASKSTATE_COMPLETED);
//				} else {
//					if (succOperationTask.getCompleteQty() > 0) {
//						succOperationTask.setTaskState(OperationTask.TASKSTATE_STARTED);
//					}
//				}
//
//				Employee loginUser = employeeDao.getById(SysUtil.getSessionEmployeeUid());
//				if (succOperationTask.getDeptUid() == null)
//					succOperationTask.setDeptUid(loginUser.getDeptUid());
//				if (succOperationTask.getMasterShopUid() == null)
//					succOperationTask.setMasterShopUid(loginUser.getDeptUid());
//
//				operationTaskDao.add(succOperationTask);
//
//				// 拷贝taskpart
//				taskpartlist = succOperationTask.getTaskParts();
//				for (TaskPart objTaskPart : taskpartlist) {
//					TaskPart newtaskpart = new TaskPart();
//					newtaskpart.setAllocatedQty(0f);
//					newtaskpart.setApplyQty(0f);
//					newtaskpart.setEffective(true);
//					newtaskpart.setPartUid(objTaskPart.getPartUid());
//					newtaskpart.setPreAssignQty(0f);
//					newtaskpart.setSingleIn(objTaskPart.getSingleIn());
//					newtaskpart.setReqQty(objTaskPart.getSingleIn() * succOperationTask.getPlanQty());
//					newtaskpart.setReqType(0);
//					newtaskpart.setSingleOut(objTaskPart.getSingleOut());
//					newtaskpart.setTaskUid(succOperationTask.getUuid());
//					taskPartDao.add(newtaskpart);
//				}
//
//				// ---------beginning---------维护Link里面的链接
//				temp_link.setPredOperationTaskUid(newoperationtaskuid);
//				// 更改Link里面的后置任务为新生成的后置任务编码
//				temp_link.setSuccOperationTaskUid(newcreatedtaskuid);
//				// 更改链接里面的数量
//				// 试样工序，不更改数量
//				if (!isTestOperation) {
//					temp_link.setLinkQty(temp_link.getLinkQty() * singleout);
//				}
//				operationTaskLinkDao.add(temp_link);
//
//				copyOperationTasks(parttaskuid, temp_succuid, newcreatedtaskuid, temp_planqty, temp_sumqty, batchnum,
//						taskpartlist);
//			} catch (Exception e) {
//				// logger.error("拷贝工序时出错！"+e);
//			}
//			// 更改前置任务为调用这个函数时传过来的工序任务标号
//
//		}
//
//	}
//
//	/** 更改当前选中的工序任务和链接关系中的属性（planqty, taskwork,linkqty）递归函数 **/
//	public void changePropertyOfOperationTaskAndLinks(String operationtaskuid, String parttaskuid,
//			Vector<String> collection_operationtaskuid, float first_planqty, float first_sumqty,
//			float first_completeqty, String batchnum, ArrayList<TaskPart> taskpartlist) {
//
//		// 标示是否为试样工序
//		boolean isSampleOperation = false;
//
//		loopsum++;
//		// 更改现在的工序任务的属性
//		float singleout = 1;
//
//		try {
//			OperationTask temp_operationtask = operationTaskDao.getById(operationtaskuid);
//			// 更改planqty
//			// 试样工序不更该计划数量
//			Operation tmpOperation = operationDao.getById(temp_operationtask.getOperationUid());
//			if (!temp_operationtask.getTaskType().equalsIgnoreCase(OperationTask.TASKTYPE_SAMPLE)) {
//				// modified by dbc 2006-08-16 begin
//
//				if (tmpOperation != null && first_sumqty != 0) {
//					singleout = tmpOperation.getBaseYield();
//				}
//				temp_operationtask.setPlanQty(first_planqty * singleout);
//				first_planqty = temp_operationtask.getPlanQty();
//				// modified by dbc 2006-08-16 end
//			} else {
//				isSampleOperation = true;
//				if (tmpOperation != null) {
//					if (tmpOperation.getSamplePercent() > 0 && tmpOperation.getSamplePercent() < 1)// 如果采用百分比试样
//						temp_operationtask
//								.setPlanQty((float) Math.ceil(first_planqty * tmpOperation.getSamplePercent()));// 按照百分比设置试样
//					else if (tmpOperation.getSampleQty() > 0)// 如果数量为固定试样数量
//						temp_operationtask.setPlanQty(tmpOperation.getSampleQty());
//					else
//						temp_operationtask.setPlanQty(1f);// 缺省试样数量为1
//				}
//			}
//			tmpOperation = null;
//			// //更改工时
//			// temp_operationtask.setTaskWork(
//			// temp_operationtask.getPreOpTime() +
//			// temp_operationtask.getRunTime() * first_planqty);
//			// 更改批次号
//			temp_operationtask.setBatchNum(batchnum);
//			if (loopsum == 1) {
//				temp_operationtask.setCompleteQty(first_completeqty);
//			}
//			if (temp_operationtask.getCompleteQty() >= temp_operationtask.getPlanQty()) {
//				temp_operationtask.setTaskState(OperationTask.TASKSTATE_COMPLETED);
//			} else {
//				if (temp_operationtask.getCompleteQty() > 0) {
//					temp_operationtask.setTaskState(OperationTask.TASKSTATE_STARTED);
//				}
//			}
//			// 更新任务
//			operationTaskDao.update(temp_operationtask);
//
//			// 暂时无用
//			// //更新taskpart
//			// taskpartlist=TaskPart.findTaskPartsByTaskUID(operationtaskuid);
//			// TaskPart objTaskPart=new TaskPart();
//			// int i=0;
//			// for(i=0;i<taskpartlist.size();i++){
//			// objTaskPart= (mm.task.object.TaskPart) taskpartlist.get(i);
//			// objTaskPart.setQtyReq(objTaskPart.getSingleIn()*temp_operationtask.getPlanQty());
//			// objTaskPart.editItem();
//			// }
//
//		} catch (Exception ex) {
//			// logger.info(
//			// "errors occur when update the existing operation tasks!");
//			ex.printStackTrace();
//		}
//		/////////////////////////////////////////////////
//		// 2004/05/31插入新的工序任务时，要考虑对Task_Part的影响
//		// 在Task_Part里面插入记录
//		// Vector collection_Taskpart = new Vector();
//		// TaskPart taskpart = new TaskPart();
//		// collection_Taskpart =
//		///////////////////////////////////////////////// taskpart.getTaskPartByTaskuid(operationtaskuid);
//		// Iterator collection_taskpart = collection_Taskpart.iterator();
//		// logger.info(
//		// "the size of cosuming Opertion of first operation is"
//		// + collection_Taskpart.size());
//		// if (collection_Taskpart.size() > 0) {
//		// int f = 0;
//		// while (collection_taskpart.hasNext()) {
//		// TaskPart temp_taskpart =
//		// (TaskPart) collection_Taskpart.elementAt(f);
//		// temp_taskpart.setQtyReq(temp_taskpart.getQtyReq() * ratio);
//		// temp_taskpart.editItem();
//		// collection_taskpart.next();
//		// f++;
//		// }
//		// }
//		// 2004/05/31the end of inserting a record to Task_Part
//		/////////////////////////////////////////////////
//		// 更改链接里面相关的属性
//		/**
//		 * 在更改链接中的数量的时候，后置链接一定要改，前置链接根据是否为工序任务来判断是否
//		 * 更改，如果是工序任务，数量不更改，如果是零部件任务，数量要更改
//		 **/
//		/////////////////////////////////////////
//		// 更改前置链接的数量(判断是否为工序任务)
//		List<OperationTaskLink> preLinks = operationTaskLinkDao.getPredOperationTaskLinks(operationtaskuid);
//		OperationTaskLink temp_prelink = new OperationTaskLink();
//
//		for (OperationTaskLink temp_link : preLinks) {
//			String temp_pretaskuid = temp_link.getPredOperationTaskUid();
//			// 不用判断是否为工序任务，所有的连接都要*ratio
//			// add by zly 试样工序不更该数量
//			if (!isSampleOperation) {
//				temp_link.setLinkQty(temp_link.getLinkQty() * singleout);
//			}
//			operationTaskLinkDao.update(temp_link);
//		}
//
//		// 更改后置链接的数量
//		List<OperationTaskLink> succLinks = operationTaskLinkDao.getSuccOperationTaskLinks(operationtaskuid);
//
//		for (OperationTaskLink temp_link : succLinks) {
//			String temp_succuid = new String(temp_link.getSuccOperationTaskUid());
//			// 判断这个链接的任务是否为当前零部件任务下的一个工序任务
//			boolean ifexsit = collection_operationtaskuid.contains(temp_succuid);
//			// 判断这个succuid是否在所取到的所有工序任务里面,这个地方调试的时候要注意
//			if (ifexsit == true) {
//				// temp_link.setLinkQty(temp_link.getLinkQty() * ratio);
//				// temp_link.updateLinks();
//
//				if (first_sumqty == 0)
//					first_sumqty = 1;// added by dbc 2006-08-16
//				changePropertyOfOperationTaskAndLinks(temp_succuid, parttaskuid, collection_operationtaskuid,
//						first_planqty, first_sumqty, first_completeqty, batchnum, taskpartlist);
//			} else {
//				// 如果工序任务连接到了一个零部件任务，那么更改链接的数量特征，但是不继续递规
//				// logger.info(
//				// "now++++++++++++++ a operation task links+++++++++++++ a part
//				// task");
//				// temp_link.setLinkQty(temp_link.getLinkQty() * ratio);
//			}
//		}
//
//	}
//
//	/**
//	 * 处理分批工序的派工记录: 如果已经派工并已开始加工，那么封存原派工，并将派工记录设为已完成。 如果派工尚未开始加工，那么删除原来的派工记录。
//	 * 
//	 * 参数: task_root--开始分批的工序任务
//	 */
//	private void releaseTaskAssignment(String task_root) throws Exception {
//		// 得到工序对应的派工记录的聚集
//		List<AssignmentDevice> assnDevices = assignmentDeviceDao.getAssignmentDevices(task_root);
//		for (AssignmentDevice ass : assnDevices) {
//			String assnUID = ass.getUuid();
//
//			int workRecordCount = workRecordDao.getWorkRecordCountByAssnDeviceUid(assnUID);
//			if (workRecordCount > 0) { // 如果已经开始加工，那么将派工记录的状态设为完成
//				ass.setAssnState(2);
//			} else if (workRecordCount == 0) { // 如果尚未开始加工，那么将派工记录的状态设为取消
//				ass.setAssnState(3);
//			}
//			assignmentDeviceDao.update(ass);
//		}
//	}
//
//	// /**
//	// * 查找所有的后道工序 基于引用传递的递归调用
//	// */
//	// private void findSuccOperation(String operationtaskuid, String
//	// partTaskuid,
//	// java.util.Vector collection_operationtaskuid) throws Exception {
//	// collection_operationtaskuid.add(operationtaskuid);
//	// mm.task.object.Task temp_task = new mm.task.object.Task();
//	// mm.task.object.Link temp_link = new mm.task.object.Link();
//	// java.util.Vector succlinks =
//	// temp_link.getLinkByPreduid(operationtaskuid);
//	// java.util.Iterator current_link = succlinks.iterator();
//	// while (current_link.hasNext()) {
//	// temp_link = (mm.task.object.Link) current_link.next();
//	// String strSuccTaskUID = temp_link.getSuccUID();
//	// /**
//	// * 如果后道工序属于本零件任务,那么递归调用本方法,从而找到所有的后道工序
//	// */
//	// if
//	// (temp_task.getTaskByTaskUID(strSuccTaskUID).getParentUID().equals(partTaskuid))
//	// {
//	// findSuccOperation(strSuccTaskUID, partTaskuid,
//	// collection_operationtaskuid);
//	// }
//	// }
//	//
//	// logger.info("_____find_____all succ operationTask_____");
//	// }
//
//	/**
//	 * 查找零件任务对应的最后一道工序
//	 */
//	private OperationTask findLastOperationTask(String partTaskuid) throws Exception {
//
//		PartTask temp_task = partTaskDao.getById(partTaskuid);
//		List<OperationTask> operationTasks = temp_task.getOperationTasks();
//		OperationTaskLink temp_link = new OperationTaskLink();
//		String lastTaskuid = new String();
//		/**
//		 * 如果零件任务没有工序任务，返回空值
//		 */
//		if (operationTasks == null) {
//			return null;
//		}
//		for (OperationTask tempOT : operationTasks) {
//			Set<OperationTaskLink> succLinks = tempOT.getSuccOperationTaskLinks();
//			if (succLinks == null) {
//				continue;
//			}
//			boolean isNotLast = false;
//			for (OperationTaskLink succlink : succLinks) {
//				OperationTask succOperationTask = succlink.getSuccOperationTask();
//				if (succOperationTask.getParentTaskUid().equals(partTaskuid)) {
//					isNotLast = true;
//				}
//			}
//			if (isNotLast == false) {
//				lastTaskuid = temp_task.getUuid();
//				break;
//			}
//		}
//
//		OperationTask lastTask = operationTaskDao.getById(lastTaskuid);
//
//		return lastTask;
//	}
//
//	/**
//	 * 查找所有的后道工序 基于引用传递的递归调用
//	 */
//	private void findSuccOperation(String operationtaskuid, String partTaskuid,
//			Vector<String> collection_operationtaskuid) throws Exception {
//
//		OperationTask ot = operationTaskDao.getById(operationtaskuid);
//		collection_operationtaskuid.add(operationtaskuid);
//		OperationTask temp_task = new OperationTask();
//		// OperationTaskLink temp_link = new OperationTaskLink();
//
//		Set<OperationTaskLink> succlinks = ot.getSuccOperationTaskLinks();
//		for (OperationTaskLink temp_link : succlinks) {
//			OperationTask succOperationTask = temp_link.getSuccOperationTask();
//			/**
//			 * 如果后道工序属于本零件任务,那么递归调用本方法,从而找到所有的后道工序
//			 */
//			if (succOperationTask.getParentTaskUid().equals(partTaskuid)) {
//				findSuccOperation(temp_link.getSuccOperationTaskUid(), partTaskuid, collection_operationtaskuid);
//			}
//		}
//		// logger.info("_____find_____all succ operationTask_____");
//	}
//
//	public void refreshTaskDistance(String partTaskUid, Double afterOperationId, Integer beginTaskDistance)
//			throws Exception {
//
//		// log.debug("开始刷新工序距离" + partTaskUid);
//		// TODO Auto-generated method stub
//		PartTask partTask = partTaskDao.getById(partTaskUid);
//		OperationTask currentOperationTask = null;
//		List<OperationTask> operationTaskList = null;
//		try {
//			if (afterOperationId == null)
//				operationTaskList = partTask.getOperationTasks();
//			else
//				operationTaskList = this.operationTaskDao.getOperationTasksByPartTaskUid(partTaskUid, afterOperationId,
//						false);
//
//			if (operationTaskList == null || operationTaskList.size() == 0)
//				return;
//			int iDistance = beginTaskDistance == null ? 0 : beginTaskDistance;
//			int iSize = operationTaskList.size();
//
//			for (int j = 0; j < iSize; j++) {
//				OperationTask operationTask = operationTaskList.get(j);
//				// 如果已经完成
//				if (operationTask.isFinished()) {
//					iDistance = 0;
//					continue;
//				}
//				if (iDistance == 0) {
//					currentOperationTask = operationTask;
//				}
//				// log.debug("开始刷新工序" + operationTask+",工序");
//				operationTask.setTaskDistance(iDistance);
//				iDistance++;
//				operationTaskDao.update(operationTask);
//
//			}
//		} catch (Exception e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		}
//
//		if (currentOperationTask != null) {
//			PartTask tmpPartTask = currentOperationTask.getPartTask();
//			if (tmpPartTask != null) {
//				tmpPartTask.setCurrentOperationTaskUid(currentOperationTask.getTaskUid());
//				tmpPartTask.setCurrentOperationTask(currentOperationTask);
//			}
//		}
//
//	}
//
//	public void syncPartTaskPlanInfo(PartTask partTask) throws Exception {
//
//		SimpleDateFormat formatDate = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
//		ScheduleEvent scheduleEvent = new ScheduleEvent();
//		scheduleEvent.setEventType(ScheduleEvent.EVENTTYPE_PARTTASK_PLANINFO);
//		scheduleEvent.setKeyUid(partTask.getUuid());
//
//		Element taskElement = new Element("Task");
//		taskElement.setAttribute("taskUid", partTask.getUuid());
//		// 开始时间
//		Date lateFinish = partTask.getLateFinish();
//		String s = (lateFinish != null) ? formatDate.format(lateFinish) : "";
//		taskElement.setAttribute("lateFinish", s);
//		s = (partTask.getIsCritical() != null) ? partTask.getIsCritical().toString() : "0";
//		taskElement.setAttribute("isCritical", s);
//		// 更新计划数量
//		// by lqm 2014-5-13
//		taskElement.setAttribute("planQty", String.valueOf(partTask.getPlanQty()));
//		// 更新计划状态
//		// by lqm 2014-5-13
//		taskElement.setAttribute("taskState", String.valueOf(partTask.getTaskState()));
//
//		Format format = Format.getCompactFormat();
//		format.setEncoding("UTF-8");
//		format.setIndent("  ");
//		XMLOutputter outputter = new XMLOutputter(format);
//		scheduleEvent.setEventContent(outputter.outputString(taskElement));
//
//		scheduleEvent.setEventState(ScheduleEvent.EVENTSTATE_DRAFT);
//
//		scheduleEvent.setSourceUid(partTask.getTaskUid());
//		scheduleEvent.setSourceType("零件任务计划信息更新");
//		scheduleEvent.setCreatorUid(SysUtil.getSessionEmployeeUid());
//		scheduleEvent.setCreateTime(new Date());
//		/**
//		 * 避免频繁更新
//		 */
//		scheduleEventManager.SaveOrUpdateBySource(partTask.getMasterShopUid(), scheduleEvent);
//
//	}
//
//	// /**
//	// * ADDED BY GONG, 更新计划数量方法;
//	// */
//	// public void UpdateCompleteQty(List<OperationTask> taskList) {
//	// javax.transaction.UserTransaction ut = null;
//	//
//	// try {
//	//
//	// java.util.Iterator taskIterator = taskList.iterator();
//	// mm.task.object.Task aTask = new mm.task.object.Task();
//	// boolean useOldTask = false; // 分批后是否继续使用原批次
//	// while (taskIterator.hasNext()) {
//	// aTask = (mm.task.object.Task) taskIterator.next();
//	// String TaskUID =
//	// mm.task.object.Task.findByPartNumberBatchnumOperationIDDESC(aTask.getPart_Number(),
//	// aTask.getBatchNum(), aTask.getOperation_iddesc());
//	// System.out.println("----TASKUID----" + TaskUID + "%%%%%%%%"
//	// + "aTask.getPart_Number(), aTask.getBatchNum(),
//	// aTask.getOperation_iddesc()" + "=="
//	// + aTask.getPart_Number() + "//" + aTask.getBatchNum() + "//" +
//	// aTask.getOperation_iddesc());
//	// mm.task.object.Task bTask = mm.task.object.Task.findByTaskUID(TaskUID);
//	// bTask.setCompleteQty(aTask.getCompleteQty());
//	// if (bTask.getCompleteQty() >= bTask.getPlanQty()) {
//	// if (bTask.getCompleteQty() > bTask.getPlanQty())
//	// bTask.setCompleteQty(bTask.getPlanQty());
//	// bTask.setTaskState(209);
//	// } else {
//	// if (bTask.getCompleteQty() > 0)
//	// bTask.setTaskState(207);
//	// }
//	// // bTask.setUpdateMode(mm.task.object.Task.MODIFY);
//	// bTask.editItem();
//	// }
//	// // ut.commit();
//	// }
//	//
//	// catch (Exception e) {
//	// e.printStackTrace();
//	// }
//	//
//	// }
//
//	/**
//	 * 判断一个零件任务是否完成 如果最后一道工序完成，自动完成该批零件任务 如果最后一道检验工序完成，也自动完成该批次零件任务
//	 * 
//	 * @param partTaskUid
//	 * @return
//	 */
//	public boolean isPartTaskFinish(String partTaskUid) {
//		try {
//			List<OperationTask> operationTasks = operationTaskDao.getOperationTasksByPartTaskUid(partTaskUid, true);
//			int i = 0;
//			for (OperationTask operationTask : operationTasks) {
//				if (i == 0) {
//					if (operationTask.getTaskState() >= OperationTask.TASKSTATE_COMPLETED) {
//						return true;
//					} else if (OperationTask.TASKTYPE_CHECK.equals(operationTask.getTaskType())) {
//						return false;
//					}
//				} else {
//					if (OperationTask.TASKTYPE_CHECK.equals(operationTask.getTaskType()))
//						return operationTask.getTaskState() >= OperationTask.TASKSTATE_COMPLETED;
//				}
//				i++;
//			}
//		} catch (Exception e) {
//			e.printStackTrace();
//		}
//		return false;
//	}
//
//	@Override
//	public void finishPartTask(String taskUid) throws Exception {
//		PartTask partTask = this.getById(taskUid);
//		if (partTask != null)
//			this.finishPartTask(partTask);
//		else {
//			throw new Exception("无法找到对应零组件任务，" + taskUid);
//		}
//	}
//
//	@Override
//	public void finishPartTask(PartTask partTask) throws Exception {
//		if (partTask.getTaskState() >= PartTask.TASKSTATE_COMPLETED) {
//			return;
//		}
//		partTask.setActualFinish(new Date());
//		partTask.setTaskState(PartTask.TASKSTATE_COMPLETED);
//		partTask.setCompleteQty(partTask.getPlanQty());
//		try {
//			this.update(partTask);
//		} catch (Exception e) {
//			e.printStackTrace();
//		}
//
//		// // 零件任务完成前将其所有挂接的工序任务完成
//		// List<OperationTask> unFinishOps = operationTaskDAO
//		// .getUnFinishTasksByPartTask(partTask.getTaskUid());
//		// if (null != unFinishOps && 0 < unFinishOps.size()) {
//		// for (OperationTask unFinishOpTask : unFinishOps) {
//		// // lqm todo
//		// // 这里放得有些另类
//		// // unFinishOpTask.setActualFinish(new Date());
//		// // 强制工序任务状态完成，只改变工序任务状态值
//		// unFinishOpTask.setTaskState(OperationTask.TASKSTATE_COMPLETED);
//		// }
//		// this.operationTaskManager.update(unFinishOps);
//		// }
//
//		// 同步计划信息
//		try {
//			this.syncPartTaskPlanInfo(partTask);
//		} catch (Exception e) {
//			e.printStackTrace();
//		}
//
//		// 将零件任务的前置零件任务也完成
//		if (sysUtil.isDeptExist(partTask.getMasterShopUid(), "taskCascadeDept")) {
//			List<PartTask> predPartTasks = partTaskLinkDao.getPredPartTasks(partTask.getTaskUid());
//			if (null != predPartTasks && 0 < predPartTasks.size()) {
//				for (PartTask predPartTask : predPartTasks) {
//					finishPartTask(predPartTask);
//				}
//			}
//		}
//	}
//
//	public void startPartTask(String partTaskUid) throws Exception {
//		PartTask partTask = this.getById(partTaskUid);
//		if (partTask != null)
//			this.startPartTask(partTask);
//		else {
//			throw new Exception("无法找到对应零组件任务，" + partTaskUid);
//		}
//	}
//
//	@Override
//	public void startPartTask(PartTask partTask) throws Exception {
//		if (partTask.getTaskState() == PartTask.TASKSTATE_STARTED) {
//			return;
//		}
//		partTask.setActualStart(new Date());
//		partTask.setActualFinish(null);
//		partTask.setCompleteQty(0f);
//		partTask.setTaskState(PartTask.TASKSTATE_STARTED);
//		try {
//			this.update(partTask);
//		} catch (Exception e) {
//			e.printStackTrace();
//		}
//		if (sysUtil.isDeptExist(partTask.getMasterShopUid(), "taskCascadeDept")) {
//			List<PartTask> predPartTasks = partTaskLinkDao.getPredPartTasks(partTask.getTaskUid());
//			if (null != predPartTasks && 0 < predPartTasks.size()) {
//				for (PartTask predPartTask : predPartTasks) {
//					finishPartTask(predPartTask);
//				}
//			}
//		}
//	}
//
//	@Override
//	public void updatePlanQty(String taskUid, Float planQty) throws Exception {
//		log.info("开始设置零件任务在制数量,任务号为：" + taskUid);
//
//		PartTask partTask = this.partTaskDao.getById(taskUid);
//		if (partTask == null) {
//			log.warn("根据TaskUid无法找到零件任务:" + taskUid);
//			return;
//		}
//		// todo
//		//
//		planQty = (float) Math.round(planQty);
//
//		/*
//		 * 记录操作日志，便于查找修改在制数数量的原因
//		 */
//		WorkRecord workRecord = new WorkRecord();
//		workRecord.setTaskUid(taskUid);
//		workRecord.setWorkerUid(SysUtil.getSessionEmployeeUid());
//		workRecord.setWorkDate(new Date());
//		workRecord.setUuid(SysUtil.getUUID());
//		workRecord.setWorkType(WorkRecord.WORKTYPE_MODIFY_PART_TASK_PLANQTY);
//		workRecord.setNotes("原数量为：" + partTask.getPlanQty() + ",新数量为：" + planQty);
//		workRecordManager.add(workRecord);
//
//		partTask.setPlanQty(planQty);
//		this.update(partTask);
//
//		// 处理挂接指令问题
//		try {
//			demandTaskLinkManager.taskQtyChange(partTask);
//		} catch (Exception e) {
//			log.error(e);
//		}
//
//		// 更新调度中的计划数量信息
//		this.syncPartTaskPlanInfo(partTask);
//
//	}
//
//	/**
//	 * 
//	 * 任务取消 计划员 功能描述 由于某种原因，某个零部件任务不再生产，但保留该零件任务相关数据，此时，计划员将任 务设为取消，任务将从此不再执行
//	 */
//	@Override
//	public void cancelPartTask(String taskUid, String operator, String cancelReason) throws Exception {
//		PartTask partTask = (PartTask) this.getById(taskUid);
//		for (OperationTask operationTask : partTask.getOperationTasks()) {
//			if (operationTask.getTaskState() < OperationTask.TASKSTATE_COMPLETED) {
//				operationTask.setTaskState(OperationTask.TASKSTATE_CANCELED);
//				this.operationTaskManager.update(operationTask);
//			}
//		}
//		log.info("session 登录人员" + SysUtil.getSessionEmployeeUid());
//		if (operator == null)
//			operator = SysUtil.getSessionEmployeeUid();
//		/*
//		 * 记录日志
//		 */
//		WorkRecord workRecord = new WorkRecord();
//		workRecord.setTaskUid(taskUid);
//		workRecord.setWorkerUid(operator);
//		workRecord.setWorkDate(new Date());
//		workRecord.setUuid(SysUtil.getUUID());
//		workRecord.setWorkType(WorkRecord.CANCEL_PART_TASK);
//		this.workRecordManager.add(workRecord);
//
//		partTask.setTaskState(PartTask.TASKSTATE_CANCELED);
//		// partTask.setActualFinish(new Date());
//
//		String strNotes = partTask.getNotes() == null ? "" : partTask.getNotes() + "\r\n";
//		if (cancelReason != null)
//			strNotes += cancelReason;
//		strNotes += " 取消人编号：" + operator;
//		partTask.setNotes(strNotes);
//
//		this.update(partTask);
//
//		// 同步计划信息
//		try {
//			this.syncPartTaskPlanInfo(partTask);
//		} catch (Exception e) {
//			e.printStackTrace();
//		}
//
//	}
//
//	@Override
//	public void rejectPartTask(String taskUid) throws Exception {
//		this.cancelPartTask(taskUid, null, "整批零件报废");
//
//		// TODO 以后在补充其它的处理方法
//
//	}
//
//	@Override
//	public void delivery(String partTaskUid, float deliveryQty) throws Exception {
//		float sum = deliveryQty;
//		PartTask partTask = (PartTask) this.getById(partTaskUid);
//		if (partTask == null)
//			throw new Exception("无法找到对应的零件任务,任务号：" + partTaskUid);
//
//		if (partTask.getDeliveryQty() == null)
//			partTask.setDeliveryQty(deliveryQty);
//		else
//			partTask.setDeliveryQty(partTask.getDeliveryQty() + deliveryQty);
//
//		List<DemandTaskLink> demandTaskLinkList = demandTaskLinkDao.getEffectiveLinksByTask(partTask.getUuid());
//
//		if (demandTaskLinkList != null && demandTaskLinkList.size() > 0) {
//			Collections.sort(demandTaskLinkList, new Comparator<DemandTaskLink>() {
//				@Override
//				public int compare(DemandTaskLink o1, DemandTaskLink o2) {
//					return o1.getDemand().getLateFinish().compareTo(o2.getDemand().getLateFinish());
//				}
//			});
//			//如果零件任务已经完全交付，那么将该零件任务与计划的交付关系都设置为无效
//			if (partTask.getDeliveryQty() >= partTask.getPlanQty()) {
//				for (DemandTaskLink demandTaskLink : demandTaskLinkList) {
//					demandTaskLink.setIsInEffect(DemandTaskLink.ISINEFFECT_ISNOT);
//				}
//			}
//			for (DemandTaskLink demandTaskLink2 : demandTaskLinkList) {
//				Demand demand = demandTaskLink2.getDemand();
//				if (demand.getDeliveryQty() == null)
//					demand.setDeliveryQty(0f);
//				if (sum > demandTaskLink2.getLinkQty()) {
//					demand.setDeliveryQty(demand.getDeliveryQty() + demandTaskLink2.getLinkQty().floatValue());
//					demandTaskLink2.setIsInEffect(DemandTaskLink.ISINEFFECT_ISNOT);
//					sum = sum - demandTaskLink2.getLinkQty().floatValue();
//				} else {
//					demand.setDeliveryQty(demand.getDeliveryQty() + sum);
//					sum = 0;
//				}
//				if (demand.getDeliveryQty() >= demand.getDueQty()) {
//					demand.setDemandState(Demand.DEMANDSTATE_FINISHED);
//					demandManager.updateSuccDemands(demand);  
//				}
//
//				if (demand.getDueQty() > 0) {
//					demand.setCompletePercent(demand.getDeliveryQty() / demand.getDueQty());
//				}
//				demandDao.update(demand);
//				demandTaskLinkDao.update(demandTaskLink2);
//			}
//		}
//
//		List<WorkOrder> wList = workOrderDao.getWorkOrderByPartUid(partTask.getPartUid());
//		if (wList != null && wList.size() > 0) {
//			WorkOrder workOrder = wList.get(0);
//			if (!workOrder.getWorkOrderState().equals(Demand.DEMANDSTATE_FINISHED)) {
//				workOrder.setDeliveryQty(workOrder.getDeliveryQty() + deliveryQty);
//				if (workOrder.getDueQty().floatValue() <= workOrder.getDeliveryQty()) {
//					workOrder.setWorkOrderState(Demand.DEMANDSTATE_FINISHED);
//				}
//			}
//			workOrderDao.update(workOrder);
//		}
//		this.update(partTask);
//
//	}

}
